The software architecture of a program or computing system is the structure or structures of the system, which comprise software elements, the externally visible properties of those elements, and the relationships between them. The term also refers to documentation of a system's software architecture. Documenting software architecture facilitates communication between software designers, documents early decisions about high-level design, and allows reuse of software components and structures between projects. Software architecture is an essential part of the design process, giving programming teams the ability to work together as a group and to see how all the components will link together.
Architecture description languages (ADLs) are used to describe a software architecture. Several different ADLs have been developed by different organizations, including Wright (developed by Carnegie Mellon), Acme (developed by Carnegie Mellon), xADL (developed by UCI), Darwin (developed by Imperial College London), DAOP-ADL (developed by University of Málaga).
Software architecture is commonly organized in views, which are analogous to the different types of blueprints made in building architecture. Within the ontology established by ANSI/IEEE 1471-2000, views are instances of viewpoints, where a viewpoint exists to describe the architecture in question from the perspective of a given set of stakeholders and their concerns. Some possible views are:
Functional/logic view
Code view
Development/structural view
Concurrency/process/thread view
Physical/deployment view
User action/feedback view
Software architecture has been described as a collection of components together with a description of the interactions between these components. Software architecture has also been described as a set of elements including processing elements, data elements and connecting elements that can be represented in some type of block diagram or flowchart.
There are many well-known styles of software architecture that software designers and developers regularly use. Terms that describe style, such as client-server, object-oriented, distributed, multi-processor, layered, message passing and preemptive are widely used and software designers and developers have an intuitive understanding of their meaning without a rigorous definition. Most software implementations however, especially large projects, are hybrids of various styles of architecture and cannot be easily classified or analyzed with respect to a single style.
Software architectures for most software systems are not documented and even when they are documented, the actual implementations deviate from the intended architecture. There are at least two causes for this deviation. Firstly, a software system does not have a single architecture. It may have many, depending on a particular point of view. There is a run-time architecture, a data-flow architecture, a control-flow architecture, a code-structure architecture and so on. Secondly, the architecture that is represented in a system's documentation may not coincide with any of these views as the software evolves over time through new releases.
A description of a large software system with any of the conventional ADLs mentioned above will be incomplete because some pieces of the software will not fit the particular architectural style used by the ADL. Additionally, non-graphical methods for describing software architecture (e.g., tables) are difficult to read and understand. It would be advantageous, therefore, to have a tool for visualizing software architecture without constraining the visualization to any single predefined style so that the software architecture can be characterized, explored and understood at any stage of development, deployment or revision.